module turn_test_fkoa {
	export declare class 敌人配置{
		unit_list:Array<any>;
		constructor()
	}
	function _TRIG_测试_FUNC(this: void, 当前触发器: Trigger, e:base.EventPlayerKeyDown) {
		if (true) {
			if (((e.key_keyboard == KeyboardKey["N"]))) {
				base.push_turn();
			} else {
			}
		}
	}
	export let 测试 = base.trigger_new(_TRIG_测试_FUNC, [], true, undefined, true)
	function _TRIG_游戏开始_FUNC(this: void, 当前触发器: Trigger, e:base.EventGameStart) {
		if (true) {
			turn_test_fkoa.func_初始化玩家队伍(base.player(1), base.get_default_unit("测试_1", "大地图_英雄", "测试"));
			((base.game) as unknown as base.Game).load_scene(Scene["default"]);
		}
	}
	export let 游戏开始 = base.trigger_new(_TRIG_游戏开始_FUNC, [], false, undefined, true)
	export let func_切换地图黑屏:(持续时间:number, 跳转玩家:Player)=>undefined = (持续时间:number, 跳转玩家:Player):undefined => {
		base.send_custom_event(new turn_test_fkoa.event_切换地图黑屏(((base.game) as unknown as base.Game), 持续时间, 跳转玩家));
	}
	export let func_ui更新行动队列:()=>undefined = ():undefined => {
		let 单位id数组: Array<number> = new Array<number>();
		let 行动类型数组: Array<number> = new Array<number>();
		let id: number | undefined;
		let 大招: turn_test_fkoa.大招 | undefined;
		// 如果是大招回合，那么说明已经开始插入大招，把大招队列放在最前面
		if (((turn_test_fkoa.g_bol_大招回合 == true))) {
			if (turn_test_fkoa.v_插入大招array !== undefined) {
				for (let [索引, 匹配的大招] of base.ArrayIterator(turn_test_fkoa.v_插入大招array as unknown as Array<turn_test_fkoa.大招>)) {
					id = 匹配的大招.单位.get_id();
					单位id数组.push(id);
					行动类型数组.push(2);
				}
			} else {
				log.warn("不能遍历：turn_test_fkoa.v_插入大招array")
			}
		} else {
		}
		turn_test_fkoa.g_unit_回合制队列.forEachEx((元素:Unit, 引用:number):boolean | undefined => {
			id = 元素.get_id();
			单位id数组.push(id);
			行动类型数组.push(1);
			// 如果不是大招回合，那么把大招队列插在第一个行动之后
			if ((((引用 == 0) && (turn_test_fkoa.g_bol_大招回合 == false)))) {
				if (turn_test_fkoa.v_插入大招array !== undefined) {
					for (let [索引, 匹配的大招] of base.ArrayIterator(turn_test_fkoa.v_插入大招array as unknown as Array<turn_test_fkoa.大招>)) {
						id = 匹配的大招.单位.get_id();
						单位id数组.push(id);
						行动类型数组.push(2);
					}
				} else {
					log.warn("不能遍历：turn_test_fkoa.v_插入大招array")
				}
			} else {
			}
		});
		base.send_custom_event(new turn_test_fkoa.event_队列更新_new(((base.game) as unknown as base.Game), 单位id数组, 行动类型数组));
	}
	export let func_战斗单位移动位置_走:(单位:Unit, 点:Point)=>undefined = (单位:Unit, 点:Point):undefined => {
		单位.walk(点);
	}
	export let func_战斗单位移动位置_瞬移:(单位:Unit, 点:Point)=>undefined = (单位:Unit, 点:Point):undefined => {
		单位.blink_ex(点);
		单位.walk(点);
		if (((单位.get_team_id() == turn_test_fkoa.g_玩家.get_team_id()))) {
			单位.set_facing(turn_test_fkoa.g_战斗_面向角度_玩家);
		} else {
			单位.set_facing(turn_test_fkoa.g_战斗_面向角度_敌人);
		}
	}
	export let g_bol_大招回合: boolean = false;
	export let g_contant_敌对玩家: Player = base.player(2);
	export let g_玩家: Player = base.player(1);
	export let g_初始位置: Map<Unit, Point> = new Map<Unit,Point>(new Array<[Unit, Point]>());
	export let g_选中的单位: Unit | undefined;
	export let g_选中的技能id: IdPreset<"spell_id"> | undefined;
	export let g_actor_候选表现: Array<Actor> = new Array<Actor>();
	export let g_actor_选中: Actor = base.create_actor_at((("$$turn_test_fkoa.actor.选中.root") as unknown as IdPreset<"actor_id">), base.scene_point(1, 1, 0, Scene["default"]), true);
	export let g_actor_行动: Actor = base.create_actor_at((("$$turn_test_fkoa.actor.行动.root") as unknown as IdPreset<"actor_id">), base.scene_point(1, 1, 0, Scene["default"]), true);
	export let g_unit_回合制队列: Array<Unit> = new Array<Unit>();
	export let g_unit_当前行动单位: Unit | undefined;
	export let g_unit_普通回合行动单位: Unit | undefined;
	export let g_战斗_面向角度_敌人: number = 210;
	export let g_战斗_面向角度_玩家: number = 20;
	export class event_队列更新 extends TriggerEvent{
		constructor(public obj:base.Game, public 单位队列:Array<number>) {
			super()
		}
		readonly event_name: string = "event_队列更新"
		readonly autoForward: boolean = true
	}
	export class event_队列更新_new extends TriggerEvent{
		constructor(public obj:base.Game, public 单位队列:Array<number>, public 行动类型队列:Array<number>) {
			super()
		}
		readonly event_name: string = "event_队列更新_new"
		readonly autoForward: boolean = true
	}
	export class event_队列更新_插入大招 extends TriggerEvent{
		constructor(public obj:base.Game, public 单位队列:Array<number>) {
			super()
		}
		readonly event_name: string = "event_队列更新_插入大招"
		readonly autoForward: boolean = true
	}
	export class event_单位行动完成 extends TriggerEvent{
		constructor(public obj:base.Game, public 单位:Unit, public 推进:boolean) {
			super()
		}
		readonly event_name: string = "event_单位行动完成"
		readonly autoForward: boolean = false
	}
	export class event_技能释放完成 extends TriggerEvent{
		constructor(public obj:Unit, public 技能:IdPreset<"spell_id">) {
			super()
		}
		readonly event_name: string = "event_技能释放完成"
		readonly autoForward: boolean = false
	}
	export class event_切换地图黑屏 extends TriggerEvent{
		constructor(public obj:base.Game, public 转场时间:number, public 跳转玩家:Player) {
			super()
		}
		readonly event_name: string = "event_切换地图黑屏"
		readonly autoForward: boolean = true
	}
	export class event_回合制战斗_进入 extends TriggerEvent{
		constructor(public obj:base.Game, public player:Player) {
			super()
		}
		readonly event_name: string = "event_回合制战斗_进入"
		readonly autoForward: boolean = true
	}
	export class event_回合制战斗_退出 extends TriggerEvent{
		constructor(public obj:base.Game, public player:Player) {
			super()
		}
		readonly event_name: string = "event_回合制战斗_退出"
		readonly autoForward: boolean = true
	}
	export let g_bol_脚本施法: boolean = false;
	export let g_bol_触发拦截施法结束: boolean = false;
	export let func_归位:(单位:Unit)=>undefined = (单位:Unit):undefined => {
		let 新变量: any;
		turn_test_fkoa.func_战斗单位移动位置_走(单位, turn_test_fkoa.g_初始位置.get(单位));
	}
	export let func_敌方行为:(战斗对象:turn_test_fkoa.回合制战斗, 单位:Unit)=>undefined = (战斗对象:turn_test_fkoa.回合制战斗, 单位:Unit):undefined => {
		let 所有技能: Array<Skill> = base.unit_all_skill(单位);
		let 己方单位: Unit = 战斗对象.get_随机玩家单位();
		let 随机到的技能: Skill = 所有技能[base.math.random_int(0, (所有技能.length - 1))];
		let 技能id: IdPreset<"spell_id"> = 随机到的技能.get_name();
		turn_test_fkoa.g_玩家.set_hero(base.get_default_unit("初始地图_9", "马甲单位"));
		if ((单位.has_buff((("$$default_units_ts.buff.眩晕.root") as unknown as IdPreset<"buff_id">)))) {
			log.info("眩晕了");
			base.timer_wait(0.5, ():void => {
				base.send_custom_event(new turn_test_fkoa.event_单位行动完成(((base.game) as unknown as base.Game), 单位, true));
			});
		} else {
			单位.cast_on_unit(随机到的技能, 己方单位);
		}
	}
	export let func_己方行为:(单位:Unit)=>undefined = (单位:Unit):undefined => {
		turn_test_fkoa.g_玩家.set_hero(单位);
	}
	export let func_指定单位行动:(行动单位:Unit)=>undefined = (行动单位:Unit):undefined => {
		turn_test_fkoa.g_unit_当前行动单位 = 行动单位;
		turn_test_fkoa.g_actor_行动.destroy(true);
		turn_test_fkoa.g_actor_行动 = base.create_actor_at((("$$turn_test_fkoa.actor.行动.root") as unknown as IdPreset<"actor_id">), turn_test_fkoa.g_unit_当前行动单位.get_scene_point(), true);
		turn_test_fkoa.g_actor_行动.play();
		if (((turn_test_fkoa.v_当前战斗 == undefined))) {
			// 战斗已经结束
			return undefined;
		} else {
		}
		if (((行动单位.get_team_id() == turn_test_fkoa.g_玩家.get_team_id()))) {
			turn_test_fkoa.func_己方行为(行动单位);
		} else {
			turn_test_fkoa.func_敌方行为(turn_test_fkoa.v_当前战斗, 行动单位);
		}
	}
	function _TRIG_trg_近战技能_移动_FUNC(this: void, 当前触发器: Trigger, e:base.EventUnitCastStart) {
		let 施法距离: number = 100;
		let 单位距离: number = 0;
		if (((turn_test_fkoa.g_bol_脚本施法 == false))) {
			if ((((e.cast.get(技能属性["是近战技能"]) == 1) && (e.target_unit_cast != undefined) && (e.target_unit_cast.get_scene_point().distance(e.unit.get_scene_point()) >= 施法距离)))) {
				turn_test_fkoa.g_bol_触发拦截施法结束 = true;
				// 先移动过去
				e.cast.bail();
				e.unit.walk(e.target_unit_cast.get_scene_point().polar_to_ex(e.target_unit_cast.get_scene_point().angle(e.unit.get_scene_point()), 施法距离));
				单位距离 = e.unit.get_scene_point().distance(e.target_unit_cast.get_scene_point());
				base.timer_wait(((单位距离 - 施法距离) / e.unit.get_ex(单位属性["移动速度"], UnitPropertySubType["Final"])), ():void => {
					turn_test_fkoa.g_bol_触发拦截施法结束 = false;
					turn_test_fkoa.g_bol_脚本施法 = true;
					e.unit.cast_on_unit(e.skill_id, e.target_unit_cast);
					log.info("触发发动技能");
					turn_test_fkoa.g_bol_脚本施法 = false;
				});
			} else {
			}
		}
	}
	export let trg_近战技能_移动 = base.trigger_new(_TRIG_trg_近战技能_移动_FUNC, [], false, undefined, true)
	function _TRIG_单位行动时_FUNC(this: void, 当前触发器: Trigger, e:base.单位行动) {
		if (true) {
			turn_test_fkoa.func_指定单位行动(e.u);
		}
	}
	export let 单位行动时 = base.trigger_new(_TRIG_单位行动时_FUNC, [], false, undefined, true)
	function _TRIG_己方施法_FUNC(this: void, 当前触发器: Trigger, e:base.EventUnitCastStop) {
		let cache: _OBJ__spell_Spell = base.eff.cache_ts<_OBJ__spell_Spell>(e.skill_id);
		let 大招: turn_test_fkoa.大招 | undefined;
		if ((((e.unit.get_string(单位字符串属性["STRING_回合制战斗单位"]) == "1") && (e.unit.get_team_id() == turn_test_fkoa.g_玩家.get_team_id()) && (turn_test_fkoa.g_bol_触发拦截施法结束 == false)))) {
			cache.Categories.filter((元素:_OBJ__AbilCategory, 引用:number):boolean => {
				if (((元素 == base.force_as<_OBJ__AbilCategory>("大招")))) {
					大招 = turn_test_fkoa.get_单位大招(e.unit);
					大招.清空能量();
					if (((turn_test_fkoa.g_bol_大招回合 == true))) {
						turn_test_fkoa.func_大招_插入回合结束();
					} else {
					}
				} else {
				}
				return true;
			});
			if (((e.skill_id == (("$$turn_test_fkoa.spell.立即行动.root") as unknown as IdPreset<"spell_id">)))) {
			} else {
				base.send_custom_event(new turn_test_fkoa.event_单位行动完成(((base.game) as unknown as base.Game), e.unit, true));
			}
		}
	}
	export let 己方施法 = base.trigger_new(_TRIG_己方施法_FUNC, [], false, undefined, true)
	function _TRIG_敌方施法_FUNC(this: void, 当前触发器: Trigger, e:base.EventUnitCastStop) {
		if ((((e.unit.get_team_id() != turn_test_fkoa.g_玩家.get_team_id()) && (e.unit.get_string(单位字符串属性["STRING_回合制战斗单位"]) == "1") && (turn_test_fkoa.g_bol_触发拦截施法结束 == false)))) {
			log.info("施法后摇时", e.unit);
			base.send_custom_event(new turn_test_fkoa.event_单位行动完成(((base.game) as unknown as base.Game), e.unit, true));
		}
	}
	export let 敌方施法 = base.trigger_new(_TRIG_敌方施法_FUNC, [], false, undefined, true)
	function _TRIG_过_FUNC(this: void, 当前触发器: Trigger, e:unknown) {
		if (true) {
		}
	}
	export let 过 = base.trigger_new(_TRIG_过_FUNC, [], false, undefined, true)
	function _TRIG_队列更新时_FUNC(this: void, 当前触发器: Trigger, e:base.队列更新) {
		if (true) {
			turn_test_fkoa.g_unit_回合制队列 = e.queue;
			turn_test_fkoa.func_ui更新行动队列();
		}
	}
	export let 队列更新时 = base.trigger_new(_TRIG_队列更新时_FUNC, [], false, undefined, true)
	function _TRIG_单位行动完成时_FUNC(this: void, 当前触发器: Trigger, e:turn_test_fkoa.event_单位行动完成) {
		let 大招: turn_test_fkoa.大招 | undefined;
		if (true) {
			turn_test_fkoa.func_归位(e.单位);
			log.info("单位行动完成时", e.单位, e.推进);
			if (((turn_test_fkoa.g_unit_当前行动单位 != e.单位))) {
				return undefined;
			} else {
			}
			大招 = base.object_restore_value(turn_test_fkoa.g_unit_当前行动单位, "大招");
			if (((大招 != undefined))) {
				log.info("大招+1", e.单位);
				大招.增加能量(1);
			} else {
				log.info("大招==nil", e.单位);
			}
			if (((turn_test_fkoa.v_当前战斗 == undefined))) {
				// 战斗已经结束
				return undefined;
			} else {
			}
			if ((((e.推进 == false)))) {
				return undefined;
			} else {
			}
			if (((turn_test_fkoa.func_插入大招检测() == true))) {
				turn_test_fkoa.func_大招_执行插入回合();
				return undefined;
			} else {
			}
			base.push_turn();
		}
	}
	export let 单位行动完成时 = base.trigger_new(_TRIG_单位行动完成时_FUNC, [], false, undefined, true)
	function _TRIG_选中单位_FUNC(this: void, 当前触发器: Trigger, e:base.EventUnitSelected) {
		if (true) {
			turn_test_fkoa.g_actor_选中 = base.create_actor_at((("$$turn_test_fkoa.actor.选中.root") as unknown as IdPreset<"actor_id">), e.unit.get_scene_point(), true);
			base.actor_attach_to_unit(turn_test_fkoa.g_actor_选中, e.unit, "socket_blood_bar");
			turn_test_fkoa.g_actor_选中.play();
			turn_test_fkoa.g_选中的单位 = e.unit;
			log.info(turn_test_fkoa.g_选中的技能id, "选中的技能");
			if (((turn_test_fkoa.g_选中的技能id != undefined))) {
				turn_test_fkoa.g_unit_当前行动单位.cast_on_unit(turn_test_fkoa.g_unit_当前行动单位.find_skill(turn_test_fkoa.g_选中的技能id), turn_test_fkoa.g_选中的单位);
			} else {
			}
		}
	}
	export let 选中单位 = base.trigger_new(_TRIG_选中单位_FUNC, [], true, undefined, true)
	function _TRIG_取消选中单位_FUNC(this: void, 当前触发器: Trigger, e:base.EventUnitUnselected) {
		if (true) {
			turn_test_fkoa.g_actor_选中.destroy(true);
			turn_test_fkoa.g_选中的单位 = undefined;
		}
	}
	export let 取消选中单位 = base.trigger_new(_TRIG_取消选中单位_FUNC, [], true, undefined, true)
	function _TRIG_单位死亡时_FUNC(this: void, 当前触发器: Trigger, e:base.EventUnitDie) {
		if (((e.unit.get_string(单位字符串属性["STRING_回合制战斗单位"]) == "1"))) {
			log.info("单位死亡", e.unit);
			base.delete_turn_unit(e.unit);
			if (((turn_test_fkoa.v_当前战斗 != undefined))) {
				turn_test_fkoa.v_当前战斗.func_单位死亡剔除(e.unit);
			} else {
			}
		}
	}
	export let 单位死亡时 = base.trigger_new(_TRIG_单位死亡时_FUNC, [], false, undefined, true)
	function _TRIG_技能被点击_FUNC(this: void, 当前触发器: Trigger, e:base.EventUnitCastStart) {
		let 己方单位: Unit;
		let 随机到的技能: Skill;
		let 单位: Unit;
		let 遍历到的单位组元素: Unit;
		let cache: _OBJ__spell_Spell = base.eff.cache_ts<_OBJ__spell_Spell>(e.skill_id);
		let 过滤: _OBJ__TargetFilter = cache.AcquireSettings.TargetUnitFilter;
		let 目标: _OBJ__Spell_target_type = cache.target_type;
		let 表现: Actor | undefined;
		if (((e.unit.get_team_id() == turn_test_fkoa.g_玩家.get_team_id()))&&(true)) {
			turn_test_fkoa.g_选中的技能id = e.skill_id;
			if (turn_test_fkoa.g_actor_候选表现 !== undefined) {
				for (let [遍历到的数组索引, 遍历到的数组元素] of base.ArrayIterator(turn_test_fkoa.g_actor_候选表现 as unknown as Array<Actor>)) {
					遍历到的数组元素.destroy(true);
				}
			} else {
				log.warn("不能遍历：turn_test_fkoa.g_actor_候选表现")
			}
			turn_test_fkoa.g_actor_候选表现 = new Array<Actor>();
			if (((过滤.敌方 == _OBJ__TargetFilter_Enum["Excluded"]))) {
				log.warn("不能生成语句: 未找到元素：[TRG_ENV: server, packageName: turn_test_fkoa, id: Variable:单位组:1160135217]")
			} else {
				log.warn("不能生成语句: 未找到元素：[TRG_ENV: server, packageName: turn_test_fkoa, id: Variable:单位组:1160135217]")
			}
			if (((turn_test_fkoa.g_选中的单位 == undefined))) {
				log.info("打断技能", e.cast, base.force_as<string>(目标));
				e.cast.bail();
			} else {
				e.unit.cast_on_unit(e.unit.find_skill(e.skill_id), turn_test_fkoa.g_选中的单位);
			}
		}
	}
	export let 技能被点击 = base.trigger_new(_TRIG_技能被点击_FUNC, [], true, undefined, true)
	export let v_当前战斗: turn_test_fkoa.回合制战斗 | undefined;
	export class 回合制战斗{
		玩家:Player = undefined;
		遇雷单位:Unit;
		玩家点:Point;
		敌人点:Point;
		array_战斗点_敌人:Array<Point>;
		array_战斗点_玩家:Array<Point>;
		敌人创建点:Point;
		玩家创建点:Point;
		group_敌人:UnitGroup = base.create_unit_group(undefined);
		group_玩家:UnitGroup = base.create_unit_group(undefined);
		玩家大地图位置:Point;
		玩家场景:Scene = Scene["测试"];
		转场时间:number = 1.5;
		行动计时器:Timer = base.timer_loop(0.2, ():void => {
			let 遍历到的单位: Unit;
			let 新变量: Unit | undefined;
			let 新变量_1: Point | undefined;
			let temp: number = 1;
			this.group_敌人.forEachEx((遍历到的单位:Unit):boolean => {
				if (((this.array_战斗点_敌人[temp].distance(遍历到的单位.get_scene_point()) <= 15))) {
					遍历到的单位.set_facing(turn_test_fkoa.g_战斗_面向角度_敌人);
				} else {
				}
				// 返回真退出循环
				temp = (temp + 1);
			});
			temp = 1;
			this.group_玩家.forEachEx((遍历到的单位:Unit):boolean => {
				if (((this.array_战斗点_玩家[temp].distance(遍历到的单位.get_scene_point()) <= 15))) {
					遍历到的单位.set_facing(turn_test_fkoa.g_战斗_面向角度_玩家);
				} else {
				}
				// 返回真退出循环
				temp = (temp + 1);
			});
		});
		func_开始:()=>void = ():void => {
			let 新变量: undefined;
			let 玩家队伍: turn_test_fkoa.玩家队伍 = turn_test_fkoa.func_获取指定玩家队伍(this.玩家);
			base.send_custom_event(new turn_test_fkoa.event_回合制战斗_进入(((base.game) as unknown as base.Game), this.玩家));
			log.info("回合制战斗-开始", this.玩家, 玩家队伍);
			// 把玩家队伍里的单位加入战斗单位组
			玩家队伍.战斗单位.forEachEx((遍历到的单位:Unit):boolean => {
				this.group_玩家.add(遍历到的单位);
			});
			// 初始化战斗点
			this.func_战斗点刷新();
			// 把玩家战斗单位移动到战斗场景
			玩家队伍.战斗单位.forEachEx((遍历到的单位:Unit):boolean => {
				遍历到的单位.find_buff((("$$turn_test_fkoa.buff.回合制_战斗隐藏.root") as unknown as IdPreset<"buff_id">)).remove();
				遍历到的单位.jump_scene(Scene["default"]);
				遍历到的单位.blink_ex(this.玩家创建点);
			});
			// 等待转场黑屏
			turn_test_fkoa.func_切换地图黑屏(this.转场时间, this.玩家);
			base.player_set_camera(this.玩家, (("$$turn_test_fkoa.camera_property.进入战斗镜头.root") as unknown as IdPreset<"camera_property_id">), (this.转场时间 / 2));
			// 转一半，最黑的时候给玩切场景，进战斗准备
			base.timer_wait((this.转场时间 / 2), ():void => {
				this.func_战斗位置刷新();
				this.func_玩家跳转战斗场景();
			});
			// 转场结束后开始战斗，给走到战场留1秒，如果是敌人先行动，给玩家一个反应时间
			base.timer_wait((this.转场时间 + 1), ():void => {
				this.func_回合制启动();
			});
		}
		func_结束:(胜利:boolean)=>void = (胜利:boolean):void => {
			let 玩家队伍: turn_test_fkoa.玩家队伍 = turn_test_fkoa.func_获取指定玩家队伍(this.玩家);
			let 大地图单位: Unit = 玩家队伍.大地图单位;
			turn_test_fkoa.func_切换地图黑屏(this.转场时间, this.玩家);
			// 等黑屏
			base.timer_wait((this.转场时间 / 2), ():void => {
				base.exit_turn_based_mode();
				turn_test_fkoa.v_当前战斗 = undefined;
				if (((胜利 == true))) {
					if (((this.遇雷单位 != undefined))) {
						this.遇雷单位.kill(大地图单位);
					} else {
					}
				} else {
				}
				玩家队伍.战斗单位.forEachEx((遍历到的单位:Unit):boolean => {
					base.unit_add_buff(遍历到的单位, (("$$turn_test_fkoa.buff.回合制_战斗隐藏.root") as unknown as IdPreset<"buff_id">), 1);
				});
				大地图单位.find_buff((("$$turn_test_fkoa.buff.回合制_战斗隐藏.root") as unknown as IdPreset<"buff_id">)).remove();
				this.玩家.set_hero(大地图单位);
				base.player_jump_scene(this.玩家, this.玩家场景, true);
				大地图单位.blink_ex(this.玩家大地图位置);
				base.player_set_camera(this.玩家, (("$$.camera_property.camerapro.root") as unknown as IdPreset<"camera_property_id">), 0);
				this.玩家.camera_focus(大地图单位);
				base.send_custom_event(new turn_test_fkoa.event_回合制战斗_退出(((base.game) as unknown as base.Game), this.玩家));
				this.func_结束销毁();
			});
		}
		func_创建敌人:(新参数:IdPreset<"unit_id">)=>void = (新参数:IdPreset<"unit_id">):void => {
			let unit: Unit = base.player_create_unit_ai(turn_test_fkoa.g_contant_敌对玩家, 新参数, this.敌人创建点, 180, false);
			unit.set_string(单位字符串属性["STRING_回合制战斗单位"], "1");
			this.group_敌人.add(unit);
		}
		func_战斗点刷新:()=>void = ():void => {
			let angle: number = -75;
			let distance: number = 200;
			let value: number = 0;
			for (let 索引 = 1; 索引 <= this.group_敌人.size; 索引 += 1) {
				value = ((索引 - ((this.group_敌人.size + 1) / 2)) * distance);
				this.array_战斗点_敌人[索引] = this.敌人点.polar_to_ex((angle + 180), value);
			}
			for (let 索引 = 1; 索引 <= this.group_玩家.size; 索引 += 1) {
				value = ((索引 - ((this.group_玩家.size + 1) / 2)) * distance);
				this.array_战斗点_玩家[索引] = this.玩家点.polar_to_ex(angle, value);
			}
		}
		func_战斗位置刷新:()=>void = ():void => {
			let temp: number = 0;
			this.group_敌人.forEachEx((遍历到的单位:Unit):boolean => {
				temp = (temp + 1);
				turn_test_fkoa.func_战斗单位移动位置_走(遍历到的单位, this.array_战斗点_敌人[temp]);
				turn_test_fkoa.g_初始位置.set(遍历到的单位, this.array_战斗点_敌人[temp]);
				// 返回真退出循环
			});
			temp = 0;
			this.group_玩家.forEachEx((遍历到的单位:Unit):boolean => {
				temp = (temp + 1);
				turn_test_fkoa.func_战斗单位移动位置_走(遍历到的单位, this.array_战斗点_玩家[temp]);
				turn_test_fkoa.g_初始位置.set(遍历到的单位, this.array_战斗点_玩家[temp]);
				// 返回真退出循环
			});
		}
		func_玩家跳转战斗场景:()=>void = ():void => {
			let 玩家队伍: turn_test_fkoa.玩家队伍 = turn_test_fkoa.func_获取指定玩家队伍(this.玩家);
			let 大地图单位: Unit = 玩家队伍.大地图单位;
			this.玩家大地图位置 = 大地图单位.get_scene_point();
			this.玩家场景 = 大地图单位.get_scene_name();
			base.player_jump_scene(this.玩家, Scene["default"], true);
			this.玩家.unlock_camera();
			// 修改镜头属性
			base.player_set_camera(this.玩家, (("$$turn_test_fkoa.camera_property.战斗镜头_初始.root") as unknown as IdPreset<"camera_property_id">), 0);
			base.player_set_camera(this.玩家, (("$$turn_test_fkoa.camera_property.战斗镜头.root") as unknown as IdPreset<"camera_property_id">), (this.转场时间 * 0.4));
			base.unit_add_buff(大地图单位, (("$$turn_test_fkoa.buff.回合制_战斗隐藏.root") as unknown as IdPreset<"buff_id">), 1);
		}
		func_回合制启动:()=>void = ():void => {
			let 新变量: undefined;
			let group: UnitGroup = base.create_unit_group(undefined);
			this.group_玩家.forEachEx((遍历到的单位:Unit):boolean => {
				group.add(遍历到的单位);
			});
			this.group_敌人.forEachEx((遍历到的单位:Unit):boolean => {
				group.add(遍历到的单位);
			});
			group.forEachEx((遍历到的单位:Unit):boolean => {
				let 所有技能: Array<Skill> = base.unit_all_skill(遍历到的单位);
				let 大招: turn_test_fkoa.大招 | undefined;
				大招 = turn_test_fkoa.get_单位大招(遍历到的单位);
				if (((大招 == undefined))) {
					// 没有注册过大招，那么注册一个
					if (所有技能 !== undefined) {
						for (let [遍历到的数组索引, 遍历到的数组元素] of base.ArrayIterator(所有技能 as unknown as Array<Skill>)) {
							遍历到的数组元素.cache.Categories.filter((元素:_OBJ__AbilCategory, 引用:number):boolean => {
								if (((元素 == base.force_as<_OBJ__AbilCategory>("大招")))) {
									log.info("大招", 引用);
									大招 = Object.assign( new turn_test_fkoa.大招(), {
										["需要能量"] : 1,
										["当前能量"] : 1,
										["大招技能id"] : 遍历到的数组元素.get_name(),
										["单位"] : 遍历到的单位,
									});
									if (((大招.当前能量 < 大招.需要能量))) {
										遍历到的单位.find_skill(遍历到的数组元素.get_name()).disable();
									} else {
									}
									base.object_store_value(遍历到的单位, "大招", 大招);
								} else {
								}
								return true;
							});
						}
					} else {
						log.warn("不能遍历：所有技能")
					}
				} else {
				}
			});
			base.enter_turn_based_mode(group);
		}
		get_随机玩家单位:()=>Unit = ():Unit => {
			return this.group_玩家.random();
		}
		func_战斗结束检测:()=>void = ():void => {
			if (((this.group_敌人.size == 0))) {
				this.func_结束(true);
			} else {
			}
			if (((this.group_玩家.size == 0))) {
				this.func_结束(false);
			} else {
			}
		}
		func_单位死亡剔除:(unit:Unit)=>void = (unit:Unit):void => {
			if ((base.unit_group_contains(this.group_敌人, unit))) {
				base.unit_group_remove_item(this.group_敌人, unit);
				this.func_战斗点刷新();
				this.func_战斗位置刷新();
				this.func_战斗结束检测();
				return undefined;
			} else {
			}
			if ((base.unit_group_contains(this.group_玩家, unit))) {
				base.unit_group_remove_item(this.group_玩家, unit);
				this.func_战斗点刷新();
				this.func_战斗位置刷新();
				this.func_战斗结束检测();
				return undefined;
			} else {
			}
		}
		func_指定单位归位:(unit:Unit)=>void = (unit:Unit):void => {
		}
		func_结束销毁:()=>void = ():void => {
			if (((this.行动计时器 != undefined))) {
				this.行动计时器.remove();
				this.行动计时器 = undefined;
			} else {
			}
		}
		constructor() {
			this.array_战斗点_敌人 = new Array<any>();
			this.array_战斗点_玩家 = new Array<any>();
		}
	}
	function _TRIG_trg_进入战斗_FUNC(this: void, 当前触发器: Trigger, e:base.造成伤害) {
		let 玩家: Player | undefined;
		if ((((e.damage_source.get_string(单位字符串属性["STRING_大地图单位"]) == "1") && (e.damage_target.get_string(单位字符串属性["STRING_大地图单位"]) == "1")))) {
			// 大地图单位打了一下，进入回合战斗
			if (((turn_test_fkoa.func_获取指定玩家队伍(e.damage_source.get_owner()) != undefined))) {
				玩家 = e.damage_source.get_owner();
				// 玩家打了敌人
				turn_test_fkoa.func_进入战斗(玩家, e.damage_target);
			} else {
				if (((turn_test_fkoa.func_获取指定玩家队伍(e.damage_target.get_owner()) != undefined))) {
					玩家 = e.damage_target.get_owner();
					// 玩家被打了
					turn_test_fkoa.func_进入战斗(玩家, e.damage_source);
				} else {
				}
			}
			// 给被打的单位加个短暂晕眩
			base.unit_add_buff(e.damage_target, (("$$turn_test_fkoa.buff.回合制_大地图被攻击晕眩.root") as unknown as IdPreset<"buff_id">), 1);
		}
	}
	export let trg_进入战斗 = base.trigger_new(_TRIG_trg_进入战斗_FUNC, [], false, undefined, true)
	export let func_进入战斗:(player:Player, enemy:Unit)=>undefined = (player:Player, enemy:Unit):undefined => {
		let 敌人配置: _OBJ_turn_test_fkoa_turn_demo_敌人配置 | undefined;
		let 单位表: Array<IdPreset<"unit_id">> | undefined;
		if (((turn_test_fkoa.v_当前战斗 != undefined))) {
			log.warn("上一场战斗未完成");
			return undefined;
		} else {
		}
		// 创建一次战斗，并填入初始数据
		turn_test_fkoa.v_当前战斗 = Object.assign( new turn_test_fkoa.回合制战斗(), {
			["玩家"] : player,
			["遇雷单位"] : enemy,
			["玩家点"] : base.get_scene_point("default", "玩家战斗位置", _G.present),
			["敌人点"] : base.get_scene_point("default", "敌人战斗位置", _G.present),
			["敌人创建点"] : base.get_scene_point("default", "敌人进场位置", _G.present),
			["玩家创建点"] : base.get_scene_point("default", "玩家进场位置", _G.present),
		});
		// 根据不同的添加战斗敌人
		敌人配置 = turn_test_fkoa.func_获取敌人队伍(enemy);
		if (((敌人配置 == undefined))) {
			log.error("警告，获取敌人配置错误", enemy);
			return undefined;
		} else {
		}
		单位表 = 敌人配置.unit_list;
		if (单位表 !== undefined) {
			for (let [索引, 单位ID] of base.ArrayIterator(单位表 as unknown as Array<IdPreset<"unit_id">>)) {
				turn_test_fkoa.v_当前战斗.func_创建敌人(单位ID);
			}
		} else {
			log.warn("不能遍历：单位表")
		}
		// 数据设置完毕，开始战斗
		turn_test_fkoa.v_当前战斗.func_开始();
	}
	export let func_获取敌人队伍:(大世界敌人:Unit)=>_OBJ_turn_test_fkoa_turn_demo_敌人配置 = (大世界敌人:Unit):_OBJ_turn_test_fkoa_turn_demo_敌人配置 => {
		switch (大世界敌人.get_name()) {
			case (("$$turn_test_fkoa.unit.不死鸟.root") as unknown as IdPreset<"unit_id">): {
				return ((base.eff.cache("$$turn_test_fkoa.turn_demo.凤凰.root")) as unknown as _OBJ_turn_test_fkoa_turn_demo_敌人配置);
			}
			case (("$$turn_test_fkoa.unit.水元素.root") as unknown as IdPreset<"unit_id">): {
				return ((base.eff.cache("$$turn_test_fkoa.turn_demo.水元素.root")) as unknown as _OBJ_turn_test_fkoa_turn_demo_敌人配置);
			}
			case (("$$turn_test_fkoa.unit.爬虫.root") as unknown as IdPreset<"unit_id">): {
				if (((base.math.random_int(0, 10) <= 5))) {
					return ((base.eff.cache("$$turn_test_fkoa.turn_demo.蜘蛛.root")) as unknown as _OBJ_turn_test_fkoa_turn_demo_敌人配置);
				} else {
					return ((base.eff.cache("$$turn_test_fkoa.turn_demo.蜘蛛_1.root")) as unknown as _OBJ_turn_test_fkoa_turn_demo_敌人配置);
				}
			}
			default : {
				break;
			}
		}
	}
	export class event_玩家_添加战斗单位 extends TriggerEvent{
		constructor(public obj:base.Game, public 玩家:Player, public 单位:Unit) {
			super()
		}
		readonly event_name: string = "event_玩家_添加战斗单位"
		readonly autoForward: boolean = false
	}
	export class 玩家队伍{
		大地图单位:Unit;
		战斗单位:UnitGroup;
		玩家:Player;
		func_添加战斗单位:(ID:IdPreset<"unit_id">)=>void = (ID:IdPreset<"unit_id">):void => {
			let unit: Unit | undefined;
			unit = base.player_create_unit_ai(this.玩家, ID, this.大地图单位.get_scene_point(), 0, false);
			base.unit_add_buff(unit, (("$$turn_test_fkoa.buff.回合制_战斗隐藏.root") as unknown as IdPreset<"buff_id">), 1);
			unit.set_string(单位字符串属性["STRING_回合制战斗单位"], "1");
			this.战斗单位.add(unit);
			base.send_custom_event(new turn_test_fkoa.event_玩家_添加战斗单位(((base.game) as unknown as base.Game), this.玩家, unit));
		}
		constructor() {
			this.战斗单位 = base.create_unit_group(undefined);
		}
	}
	export let array_玩家队伍: Array<turn_test_fkoa.玩家队伍> = new Array<turn_test_fkoa.玩家队伍>();
	export let func_初始化玩家队伍:(玩家:Player, 大地图单位:Unit)=>turn_test_fkoa.玩家队伍 = (玩家:Player, 大地图单位:Unit):turn_test_fkoa.玩家队伍 => {
		let 队伍: turn_test_fkoa.玩家队伍 | undefined = Object.assign( new turn_test_fkoa.玩家队伍(), {
			["大地图单位"] : 大地图单位,
			["战斗单位"] : undefined,
			["玩家"] : 玩家,
		});
		turn_test_fkoa.array_玩家队伍[玩家.get_slot_id()] = 队伍;
		队伍.func_添加战斗单位((("$$default_units_ts.unit.星火战士.root") as unknown as IdPreset<"unit_id">));
		队伍.func_添加战斗单位((("$$default_units_ts.unit.6、远程普攻示例英雄.root") as unknown as IdPreset<"unit_id">));
		队伍.func_添加战斗单位((("$$default_units_ts.unit.sce2号.root") as unknown as IdPreset<"unit_id">));
		return 队伍;
	}
	export let func_获取指定玩家队伍:(player:Player)=>turn_test_fkoa.玩家队伍 = (player:Player):turn_test_fkoa.玩家队伍 => {
		return turn_test_fkoa.array_玩家队伍[player.get_slot_id()];
	}
	export class event_大招面板刷新 extends TriggerEvent{
		constructor(public obj:base.Game, public 单位队列:Array<number>, public 技能link:Array<IdPreset<"spell_id">>, public 能量:Array<number>, public 能量上限:Array<number>) {
			super()
		}
		readonly event_name: string = "event_大招面板刷新"
		readonly autoForward: boolean = true
	}
	export class event_大招能量刷新 extends TriggerEvent{
		constructor(public obj:base.Game, public 单位:number, public 能量:number) {
			super()
		}
		readonly event_name: string = "event_大招能量刷新"
		readonly autoForward: boolean = true
	}
	export let v_插入大招array: Array<turn_test_fkoa.大招> = new Array<turn_test_fkoa.大招>();
	export let func_大招面板刷新:(玩家:Player)=>undefined = (玩家:Player):undefined => {
		let 玩家队伍: turn_test_fkoa.玩家队伍 = turn_test_fkoa.func_获取指定玩家队伍(玩家);
		let 单位ID: Array<number> = new Array<number>();
		let 技能link: Array<IdPreset<"spell_id">> = new Array<IdPreset<"spell_id">>();
		let 能量: Array<number> = new Array<number>();
		let 能量上限: Array<number> = new Array<number>();
		// 总体发送一次大招面板的状态
		玩家队伍.战斗单位.forEachEx((遍历到的单位:Unit, 大招:turn_test_fkoa.大招 | undefined):boolean => {
			大招 = base.object_restore_value(遍历到的单位, "大招");
			if (((大招 != undefined))) {
				单位ID.push(遍历到的单位.get_id());
				技能link.push(大招.大招技能id);
				能量.push(大招.当前能量);
				能量上限.push(大招.需要能量);
				log.info("大招", 遍历到的单位.get_id(), 大招.大招技能id, 大招.当前能量, 大招.需要能量);
			} else {
			}
		});
		base.send_custom_event(new turn_test_fkoa.event_大招面板刷新(((base.game) as unknown as base.Game), 单位ID, 技能link, 能量, 能量上限));
	}
	export let func_大招能量刷新:(玩家:Player, 单位:Unit, 大招:turn_test_fkoa.大招)=>undefined = (玩家:Player, 单位:Unit, 大招:turn_test_fkoa.大招):undefined => {
		log.info("func_大招能量刷新", 单位.get_id(), 大招.当前能量);
		// 修改单个大招的能量状态
		base.send_custom_event(new turn_test_fkoa.event_大招能量刷新(((base.game) as unknown as base.Game), 单位.get_id(), 大招.当前能量));
	}
	export let func_大招_申请释放:(单位编号:number)=>undefined = (单位编号:number):undefined => {
		if (turn_test_fkoa.v_当前战斗.group_玩家 !== undefined) {
			for (let 匹配单位 of turn_test_fkoa.v_当前战斗.group_玩家 as unknown as UnitGroup) {
				let 大招: turn_test_fkoa.大招 | undefined;
				if (((匹配单位.get_id() == 单位编号))) {
					// 如果已经在行动了就跳出
					if (((turn_test_fkoa.g_unit_当前行动单位 == 匹配单位))) {
						return undefined;
					} else {
					}
					大招 = turn_test_fkoa.get_单位大招(匹配单位);
					// 如果没有大招就跳出
					if (((大招 == undefined))) {
						return undefined;
					} else {
					}
					// 判断一下是否已经被插入了
					if (turn_test_fkoa.v_插入大招array !== undefined) {
						for (let [遍历到的数组索引, 遍历到的数组元素] of base.ArrayIterator(turn_test_fkoa.v_插入大招array as unknown as Array<turn_test_fkoa.大招>)) {
							if (((大招 == 遍历到的数组元素))) {
								return undefined;
							} else {
							}
						}
					} else {
						log.warn("不能遍历：turn_test_fkoa.v_插入大招array")
					}
					// 检测能量师傅满足需求
					if (((大招.当前能量 < 大招.需要能量))) {
						return undefined;
					} else {
					}
					turn_test_fkoa.v_插入大招array.push(大招);
					log.info("插入大招", 大招, 大招.大招技能id);
					turn_test_fkoa.func_ui更新行动队列();
				} else {
				}
			}
		} else {
			log.warn("不能遍历：turn_test_fkoa.v_当前战斗.group_玩家")
		}
	}
	export let get_单位大招:(单位:Unit)=>turn_test_fkoa.大招 | undefined = (单位:Unit):turn_test_fkoa.大招 | undefined => {
		return base.object_restore_value(单位, "大招");
	}
	export class 大招{
		需要能量:number = undefined;
		当前能量:number = undefined;
		大招技能id:IdPreset<"spell_id"> = undefined;
		单位:Unit = undefined;
		禁用:boolean = false;
		增加能量:(能量:number)=>void = (能量:number):void => {
			if (((this.当前能量 >= this.需要能量))) {
				return undefined;
			} else {
			}
			this.当前能量 = (this.当前能量 + 能量);
			turn_test_fkoa.func_大招能量刷新(this.单位.get_owner(), this.单位, this);
			if (((this.当前能量 >= this.需要能量))) {
				this.单位.find_skill(this.大招技能id).enable();
				this.禁用 = false;
			} else {
			}
		}
		清空能量:()=>void = ():void => {
			this.当前能量 = 0;
			this.单位.find_skill(this.大招技能id).disable();
			this.禁用 = true;
			turn_test_fkoa.func_大招能量刷新(this.单位.get_owner(), this.单位, this);
		}
		constructor() {
		}
	}
	export let func_插入大招检测:()=>boolean = ():boolean => {
		if (((turn_test_fkoa.v_插入大招array.length <= 0))) {
			return false;
		} else {
			return true;
		}
	}
	export let func_大招_执行插入回合:()=>void = ():void => {
		let 大招: turn_test_fkoa.大招 = turn_test_fkoa.v_插入大招array[0];
		let 单位: Unit = 大招.单位;
		let 单位数编: _OBJ__unit_Unit = 单位.cache;
		turn_test_fkoa.g_unit_回合制队列.splice(0, 1);
		log.info("插入大招回合开始");
		turn_test_fkoa.g_bol_大招回合 = true;
		if (单位数编.UnitData.HeroSkill !== undefined) {
			for (let [索引, 匹配技能id] of base.ArrayIterator(单位数编.UnitData.HeroSkill as unknown as Array<IdPreset<"spell_id">>)) {
				let 技能: Skill = 单位.find_skill(匹配技能id);
				if ((((技能 != undefined) && (大招.大招技能id != 技能.get_name())))) {
					技能.disable();
				} else {
				}
			}
		} else {
			log.warn("不能遍历：单位数编.UnitData.HeroSkill")
		}
		turn_test_fkoa.func_指定单位行动(单位);
		turn_test_fkoa.func_ui更新行动队列();
	}
	export let func_大招_插入回合结束:()=>undefined = ():undefined => {
		let 大招: turn_test_fkoa.大招 = turn_test_fkoa.v_插入大招array[0];
		let 单位: Unit = 大招.单位;
		let 单位数编: _OBJ__unit_Unit = 单位.cache;
		log.info("func_大招回合结束");
		turn_test_fkoa.v_插入大招array.splice(0, 1);
		turn_test_fkoa.g_bol_大招回合 = false;
		if (单位数编.UnitData.HeroSkill !== undefined) {
			for (let [索引, 匹配技能id] of base.ArrayIterator(单位数编.UnitData.HeroSkill as unknown as Array<IdPreset<"spell_id">>)) {
				let 技能: Skill = 单位.find_skill(匹配技能id);
				if ((((技能 != undefined) && (大招.大招技能id != 技能.get_name())))) {
					技能.enable();
				} else {
				}
			}
		} else {
			log.warn("不能遍历：单位数编.UnitData.HeroSkill")
		}
		if (((turn_test_fkoa.func_插入大招检测() == true))) {
			turn_test_fkoa.func_大招_执行插入回合();
		} else {
			base.push_turn();
		}
	}
	export let func_大招_单位初始化:(单位:Unit)=>undefined = (单位:Unit):undefined => {
		let 所有技能: Array<Skill> = base.unit_all_skill(单位);
		let 大招: turn_test_fkoa.大招 | undefined;
		大招 = turn_test_fkoa.get_单位大招(单位);
		if (((大招 == undefined))) {
			// 没有注册过大招，那么注册一个
			if (所有技能 !== undefined) {
				for (let [遍历到的数组索引, 遍历到的数组元素] of base.ArrayIterator(所有技能 as unknown as Array<Skill>)) {
					遍历到的数组元素.cache.Categories.filter((元素:_OBJ__AbilCategory, 引用:number):boolean => {
						if (((元素 == base.force_as<_OBJ__AbilCategory>("大招")))) {
							log.info("大招", 引用);
							大招 = Object.assign( new turn_test_fkoa.大招(), {
								["需要能量"] : 3,
								["当前能量"] : 3,
								["大招技能id"] : 遍历到的数组元素.get_name(),
								["单位"] : 单位,
							});
							if (((大招.当前能量 < 大招.需要能量))) {
								单位.find_skill(遍历到的数组元素.get_name()).disable();
							} else {
							}
							base.object_store_value(单位, "大招", 大招);
						} else {
						}
						return true;
					});
				}
			} else {
				log.warn("不能遍历：所有技能")
			}
		} else {
		}
	}
	function _TRIG_trg_申请释放大招_FUNC(this: void, 当前触发器: Trigger, e:event_申请释放大招) {
		if (true) {
			log.info("trg_申请释放大招", e.单位id);
			if (((turn_test_fkoa.v_当前战斗 == undefined))) {
				return undefined;
			} else {
			}
			turn_test_fkoa.func_大招_申请释放(e.单位id);
		}
	}
	export let trg_申请释放大招 = base.trigger_new(_TRIG_trg_申请释放大招_FUNC, [], false, undefined, true)
	function _TRIG_trg_大招_退出战斗_FUNC(this: void, 当前触发器: Trigger, e:turn_test_fkoa.event_回合制战斗_退出) {
		if (true) {
			// 每次战斗结束后，旧列表就抛弃掉
			turn_test_fkoa.v_插入大招array = new Array<any>();
		}
	}
	export let trg_大招_退出战斗 = base.trigger_new(_TRIG_trg_大招_退出战斗_FUNC, [], false, undefined, true)
	function _TRIG_trg_大招_进入战斗_FUNC(this: void, 当前触发器: Trigger, e:turn_test_fkoa.event_回合制战斗_进入) {
		if (true) {
			turn_test_fkoa.func_大招面板刷新(e.player);
		}
	}
	export let trg_大招_进入战斗 = base.trigger_new(_TRIG_trg_大招_进入战斗_FUNC, [], false, undefined, true)
	function _TRIG_trg_玩家_添加战斗单位_FUNC(this: void, 当前触发器: Trigger, e:turn_test_fkoa.event_玩家_添加战斗单位) {
		if (true) {
			turn_test_fkoa.func_大招_单位初始化(e.单位);
		}
	}
	export let trg_玩家_添加战斗单位 = base.trigger_new(_TRIG_trg_玩家_添加战斗单位_FUNC, [], false, undefined, true)
	export class 战斗场景{
		镜头:IdPreset<"camera_property_id">;
		玩家点:_OBJ__link_node_LinkNodeScenePoint;
		敌人点:_OBJ__link_node_LinkNodeScenePoint;
		constructor() {
		}
	}
	//以下为转发事件
	export class event_申请释放大招 extends TriggerEvent{
		constructor(public obj:base.Game, public 单位id:number, public player_slot_id:number) {
			super()
		}
		readonly event_name: string = "event_申请释放大招"
		readonly autoForward: boolean = false
	}
	export class 过 extends TriggerEvent{
		constructor(public obj:unknown, public player_slot_id:number) {
			super()
		}
		readonly event_name: string = "过"
		readonly autoForward: boolean = false
	}
	//为触发器添加事件
	测试.add_event_common({ obj: ((base.any_player) as unknown as base.PPlayerAny), event_name: "玩家-按键按下" })
	游戏开始.add_event_common({ obj: ((base.game) as unknown as base.Game), event_name: "游戏-开始" })
	trg_近战技能_移动.add_event_common({ obj: ((base.any_skill) as unknown as base.PSkillAny), event_name: "技能-施法开始" })
	单位行动时.add_event_common({ obj: ((base.game) as unknown as base.Game), event_name: "回合制模式-单位行动" })
	己方施法.add_event_common({ obj: ((base.any_skill) as unknown as base.PSkillAny), event_name: "技能-施法停止" })
	敌方施法.add_event_common({ obj: ((base.any_skill) as unknown as base.PSkillAny), event_name: "技能-施法停止" })
	队列更新时.add_event_common({ obj: ((base.game) as unknown as base.Game), event_name: "回合制模式-队列更新" })
	单位行动完成时.add_event_common({ obj: ((base.game) as unknown as base.Game), event_name: "event_单位行动完成" })
	选中单位.add_event_common({ obj: ((base.any_unit) as unknown as base.PUnitAny), event_name: "单位-选中" })
	取消选中单位.add_event_common({ obj: ((base.any_unit) as unknown as base.PUnitAny), event_name: "单位-取消选中" })
	单位死亡时.add_event_common({ obj: ((base.any_unit) as unknown as base.PUnitAny), event_name: "单位-死亡" })
	技能被点击.add_event_common({ obj: ((base.any_skill) as unknown as base.PSkillAny), event_name: "技能-施法开始" })
	trg_进入战斗.add_event_common({ obj: ((base.any_unit) as unknown as base.PUnitAny), event_name: "造成伤害" })
	trg_申请释放大招.add_event_common({ obj: ((base.game) as unknown as base.Game), event_name: "event_申请释放大招" })
	trg_大招_退出战斗.add_event_common({ obj: ((base.game) as unknown as base.Game), event_name: "event_回合制战斗_退出" })
	trg_大招_进入战斗.add_event_common({ obj: ((base.game) as unknown as base.Game), event_name: "event_回合制战斗_进入" })
	trg_玩家_添加战斗单位.add_event_common({ obj: ((base.game) as unknown as base.Game), event_name: "event_玩家_添加战斗单位" })
}
